Swift中自动引用计数

Swift 使用自动引用计数来管理内存，当每次创建一个新的类的实例的时候，ARC 会分配一块内存来存储该实例信息。内存中会包含实例的类型信息，以及这个实例所有相关的存储类型属性的值。看一个简单的例子：

class Person {
  let name: String
  init(name: String) {
    self.name = name
    print("\(name) is being initialized")
  }
  deinit {
    print("\(name) is being deinitialized")
  }
}

// 可选类型被自动初始化为 nil
var reference1: Person?
var reference2: Person?
var reference3: Person?

// John Appleseed is being initialized
// 此时 Person 的引用计数为 3
reference1 = Person(name: "John Appleseed")
reference2 = reference1
reference3 = reference1

reference1 = nil
reference2 = nil
// 当最后一个强引用的被断开时，ARC 会销毁它
// John Appleseed is being deinitialized
reference3 = nil

如果出现两个类实例之间的循环强引用，比如：

class Person {
  let name: String
  init(name: String) { self.name = name }
  var apartment: Apartment?
  deinit { print("\(name) is being deinitialized") }
}

class Apartment {
  let unit: String
  init(unit: String) { self.unit = unit }
  var tenant: Person?
  deinit { print("Apartment \(unit) is being deinitialized") }
}

// 两个可选的变量，并初始化为 nil
var john: Person?
var unit4A: Apartment?

// 创建实例
john = Person(name: "John Appleseed")
unit4A = Apartment(unit: "4A")

// 将两个实例进行关联，这样就出现了强引用
john!.apartment = unit4A
unit4A!.tenant = john

// 即使断开两个变量的引用，引用计数也并不会为 0，实例也不会被销毁。造成内存泄露
john = nil
unit4A = nil

Swift 提供两种方式来解决实例间的强引用：弱引用和无主引用。它们都允许循环引用中的一个实例引用另外一个实例不保持强引用。这样就相互引用就不会产生循环强引用。

弱引用（weak）

弱引用：不会对其引用的实例保持强引用，这样就组织了引用变为循环强引用。在声明属性或者变量时，在前面加上weak关键字表明这是一个弱引用。因为弱引用不会保持所引用的实例，即使引用存在，实例也有可能被销毁。因此，ARC 会在引用的实例被销毁后自动将其赋值为 nil 。并且因为弱引用可以允许它们的值在运行时被赋值为 nil ，所以它们会被定义为可选类型变量，而不是常量。需要注意的是：当 ARC 设置弱引用为 nil 时，属性观察不会被触发。

将上面Apartment类中的tenant属性前面使用weak来修饰，像这样：weak var tenant: Person?，就会打破循环强引用。

无主引用（`unowned`）

无主引用：和弱引用类似，无主引用不会牢牢保持住引用的实例。和弱引用不同的是，无主引用在其他实例有相同或者更长的生命周期时使用。你可以在声明属性或者变量时，在前面加上关键字 unowned 表示这是一个无主引用。无主引用通常都被期望拥有值。不过 ARC 无法在实例被销毁后将无主引用设为 nil ，因为非可选类型的变量不允许被赋值为 nil 。

注意：在使用无主引用时，必须确保引用始终指向一个未销毁的实例。如果视图在实例销毁后，访问实例的无主引用，会触发运行时错误。

举个例子，个客户可能有或者没有信用卡，但是一张信用卡总是关联着一个客户。下面表示这种关系，Customer 类有一个可选类型的 card 属性，但是 CreditCard 类有一个非可选类型的 customer 属性。

import UIKit

class Customer {
  let name: String
  var card: CreditCard?
  init(name: String) {
    self.name = name
  }
  deinit { print("\(name) is being deinitialized") }
}

class CreditCard {
  let number: UInt64
  // 这里的属性 customer 不允许被赋值为 nil
  unowned let customer: Customer
  init(number: UInt64, customer: Customer) {
    self.number = number
    self.customer = customer
  }
  deinit { print("Card #\(number) is being deinitialized") }
}

var john: Customer?
john = Customer(name: "John Appleseed")
john!.card = CreditCard(number: 1234_5678_9012_3456, customer: john!)

john = nil
// 由于 customer 为 unowned，当断开 john 变量持有的强引用，再也没有指向 Customer 实例的强引用了
// John Appleseed is being deinitialized
// Card #1234567890123456 is being deinitialized

注意：上面的例子展示了如何使用安全的无主引用。对于需要禁用运行时的安全检查的情况(例如，出于性能方面的原因)，Swift还提供了不安全的无主引用。与所有不安全的操作一样，你需要负责检查代码以确保其安全性。你可以通过 unowned(unsafe) 来声明不安全无主引用。如果你试图在实例被销毁后，访问该实例的不安全无主引用，你的程序会尝试访问该实例之前所在的内存地址，这是一个不安全的操作。

那么什么时候使用 weak 或者 unowned 呢？

当其他的实例有更短的生命周期时，使用弱引用，也就是说，当其他实例析构在先时。在上面公寓的例子中，很显然一个公寓在它的生命周期内会在某个时间段没有它的主人，所以一个弱引用就加在公寓类里面，避免循环引用。相比之下，当其他实例有相同的或者更长生命周期时，请使用无主引用。也就是：

Person 和 Apartment 的例子展示了两个属性的值都允许为 nil ，并会潜在的产生循环强引用。这种场景最适合用弱引用来解决。
å
Customer 和 CreditCard 的例子展示了一个属性的值允许为 nil ，而另一个属性的值不允许为 nil ，这也可能会产生循环强引用。这种场景最适合通过无主引用来解决。

无主引用以及隐式解析可选属性

当两个属性都必须有值，并且初始化完成后永远不会为 nil 。在这种场景中，需要一个类使用无主属性，而另外一个类使用隐式解析可选属性。这使两个属性在初始化完成后能被直接访问(不需要可选展开)，同时避免了循环引用。

class Country {
  let name: String
  // 注意这里：将 Country 的 capitalCity 属性声明为隐式解析可选类型的属性。这意味着像其他可选类型一样， capitalCity 属性的默认值为 nil ，但是不需要展开它的值就能访问它。
  var capitalCity: City!
  init(name: String, capitalName: String) {
    self.name = name
    self.capitalCity = City(name: capitalName, country: self)
  }
}

class City {
  let name: String
  unowned let country: Country
  init(name: String, country: Country) {
    self.name = name
    self.country = country
  }
}

// Country 的实例在给构造函数中给 name 属性赋完值后，整个初始化过程就完成了。 同时将 self 作为参数传递给  City 的构造函数
// capitalCity 属性能够被直接访问，不需要通过感叹号来展开它的可选值。
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// Canada's capital city is called Ottawa

闭包引起的循环强引用

通过捕获值列表作为闭包的一部分，通过这种方式可以解决闭包和类实例之间的循环强引用。捕获列表定义了闭包体内捕获一个或者多个引用类型的规则。跟解决两个类实例间的循环强引用一样，声明每个捕获的引用为弱引用或无主引用，而不是强引用。应当根据代码关系来决定使用弱引用还是无主引用。下面看一个例子：

class HTMLElement {
  let name: String
  let text: String?
  // 闭包当中使用了 self，它捕获了 HTMLElement 的实例 text，并对 self 强引用
  // 虽然闭包多次使用 self，它只捕获 HTMLElement 实例的一个强引用
  lazy var asHTML: (Void) -> String = {
    if let text = self.text {
      return "<\(self.name)>\(text)</\(self.name)>"
    } else {
      return "<\(self.name) />"
    }
  }
  init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
  }
  deinit {
    print("\(name) is being deinitialized")
  }
}

let heading = HTMLElement(name: "h1")
let defaultText = "some default text"
heading.asHTML = {
  return "<\(heading.name)>\(heading.text ?? defaultText)</\(heading.name)>"
}
print(heading.asHTML())

// 实例的 asHTML 属性持有闭包的强引用，此时在闭包内部，闭包又强引用 self。造成循环强引用
var paragraph: HTMLElement? = HTMLElement(name: "p", text: "hello, world")
print(paragraph!.asHTML())

注意：只要在闭包内使用 self 的成员，就要用 self.someProperty 或者 self.someMethod() (而不只是 someProperty 或 someMethod() )。这提醒你可能会一不小心就捕获了 self 。

解决闭包引起的强引用

如果闭包有参数列表和返回类型，把捕获值列表放在它们的前面：

lazy var someClosure: (Int, String) -> String = {
  [unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
  // 这里是闭包的函数体
}

// 如果闭包没有指明参数列表或者返回类型，即它们会通过上下文推断，那么可以把捕获列表和关键字 in 放在闭包 最开始的地方:
lazy var someClosure: Void -> String = {
  [unowned self, weak delegate = self.delegate!] in
  // 这里是闭包的函数体
}

如果闭包和捕获的实例总是相互引用并同时销毁的时候，将闭包内的捕获定义为无主引用。相反，如果被捕获的引用可能会变为 nil时，将闭包内的捕获定义为弱引用。弱引用总是可选类型，并且当引用的实例被销毁后，弱引用的值会自动置为 nil 。这使我们可以在闭包体内检查它们是否存在。

注意：如果被捕获的引用绝对不会变为 nil ，应该用无主引用，而不是弱引用。

class HTMLElement {
  let name: String
  let text: String?
  lazy var asHTML: (Void) -> String = {
    // 捕获值列表是 [unowned self]，表示将 self 捕获为无主引用而不是强引用。
    // 实例被销毁，最终会看到析构函数被调用
    [unowned self] in
    if let text = self.text {
      return "<\(self.name)>\(text)</\(self.name)>"
    } else {
      return "<\(self.name) />"
    }
  }
  init(name: String, text: String? = nil) {
    self.name = name
    self.text = text
  }
  deinit {
    print("\(name) is being deinitialized")
  }
}

弱引用（weak）

无主引用（unowned）

无主引用以及隐式解析可选属性

闭包引起的循环强引用

解决闭包引起的强引用

无主引用（`unowned`）